home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / strings.swg / 0072_Good String Unit.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1993-11-21  |  4.9 KB  |  188 lines
  1. {$O-}
  2. UNIT Strings;
  3. INTERFACE
  4.  
  5.   FUNCTION Dupe(C : Char; Len : Byte) : String;
  6.   FUNCTION ADupe(C : Char; Len : Byte) : String;
  7.   FUNCTION Pad(S : String; C : Char;
  8.                            Len : Byte) : String;
  9.   FUNCTION APad(S : String; C : Char;
  10.                             Len : Byte) : String;
  11.   FUNCTION LeftPad(S : String; C : Char;
  12.                                Len : Byte) : String;
  13.   FUNCTION ALeftPad(S : String; C : Char;
  14.                                 Len : Byte) : String;
  15.   FUNCTION Chop(S : String; len: Byte): String;
  16.   FUNCTION AChop(S : String; len: Byte): String;
  17.   FUNCTION LeftChop(S : String; len: Byte): String;
  18.   FUNCTION ALeftChop(S : String; len: Byte): String;
  19.   PROCEDURE Trim(VAR S : String; C : Char);
  20.   PROCEDURE TrimLead(VAR S : String; C : Char);
  21.  
  22. IMPLEMENTATION
  23.  
  24.   FUNCTION Dupe(C : Char; Len : Byte) : String;
  25.   VAR Temp : String;
  26.   BEGIN
  27.     FillChar(Temp[1], Len, C);
  28.     Temp[0] := Char(Len);
  29.     Dupe := Temp;
  30.   END;
  31.  
  32.   FUNCTION ADupe(C : Char;
  33.                  Len : Byte) : String; Assembler;
  34.   ASM
  35.     LES DI, @Result
  36.     CLD
  37.     XOR CH, CH
  38.     MOV CL, Len       {length in CX}
  39.     MOV AX, CX        {and in AX}
  40.     STOSB             {store length byte}
  41.     MOV AL, C
  42.     REP STOSB         {fill string with char}
  43.   END;
  44.  
  45.   FUNCTION Pad(S : String; C : Char; Len : Byte) : String;
  46.   BEGIN
  47.     IF length(S) < len THEN
  48.       FillChar(S[succ(length(S))], Len-length(S), C);
  49.     S[0] := char(Len);
  50.     Pad := S;
  51.   END;
  52.  
  53.   FUNCTION APad(S : String; C : Char;
  54.                 Len : Byte) : String; Assembler;
  55.   ASM
  56.     PUSH DS
  57.     LDS SI, S        {DS:SI points to S}
  58.     LES DI, @Result  {ES:DI points to result}
  59.     LODSB            {read existing length}
  60.     XOR AH, AH
  61.     MOV CX, AX
  62.     MOV AL, Len      {Set result to desired length}
  63.     STOSB            {Transfer length to result}
  64.     MOV BX, CX
  65.     REP MOVSB        {Now S is in @Result}
  66.     XOR CH, CH
  67.     MOV CL, Len      {Get desired length in CX}
  68.     SUB CX, BX       {Subtract current length}
  69.     JLE @NoPad       {If difference < 0, no pad}
  70.       MOV AL, C      {Put char in AL}
  71.       REP STOSB      {Fill rest of string}
  72.     @NoPad:
  73.     POP DS
  74.   END;
  75.  
  76.   FUNCTION LeftPad(S : String; C : Char;
  77.                                Len : Byte) : String;
  78.   BEGIN
  79.     IF length(S) < Len THEN
  80.       BEGIN
  81.         MOVE(S[1], S[succ(Len - length(S))], length(S));
  82.         FillChar(S[1], Len - length(S), C);
  83.       END;
  84.     S[0] := Char(Len);
  85.     LeftPad := S;
  86.   END;
  87.  
  88.   FUNCTION ALeftPad(S : String; C : Char;
  89.                     Len : Byte) : String; Assembler;
  90.   ASM
  91.     PUSH DS
  92.     CLD
  93.     LES DI, @Result  {ES:DI points to result}
  94.     MOV AL, Len
  95.     XOR AH, AH
  96.     MOV CX, AX       {Desired length in CX}
  97.     STOSB            {length byte of result}
  98.     LDS SI, S        {DS:SI points to S}
  99.     LODSB            {AL has length of S}
  100.     MOV BL, AL       {remember length of S}
  101.     SUB CX, AX       {subtract actual from desired}
  102.     JLE @NoPad       {if diff < 0, don't pad}
  103.       MOV AL, C      {fill at start of string}
  104.       REP STOSB
  105.     @NoPad:
  106.     MOV CL, BL       {get back length of S}
  107.     REP MOVSB        {copy rest of S}
  108.     POP DS
  109.   END;
  110.  
  111.   FUNCTION Chop(S : String; len : Byte): String;
  112.   BEGIN
  113.     IF length(S) > len THEN
  114.       S[0] := Char(Len);
  115.     Chop := S;
  116.   END;
  117.  
  118.   FUNCTION AChop(S : String;
  119.                  len: Byte): String; Assembler;
  120.   ASM
  121.     PUSH DS
  122.     LDS SI, S
  123.     LES DI, @Result
  124.     LODSB
  125.     XOR AH, AH
  126.     XCHG AX, CX
  127.     CMP CL, Len       {if length > len,...}
  128.     JB @NoChop
  129.       MOV CL, Len     {... set length to len}
  130.     @NoCHop:
  131.     MOV AL, CL        {store length}
  132.     STOSB
  133.     REP MOVSB         {copy Len chars to result}
  134.     POP DS
  135.   END;
  136.  
  137.   FUNCTION LeftChop(S : String; len: Byte): String;
  138.   BEGIN
  139.     IF length(S) > len THEN
  140.       BEGIN
  141.         MOVE(S[succ(length(S) - len)],
  142.              S[1], Len);
  143.         S[0] := Char(Len);
  144.       END;
  145.     LeftChop := S;
  146.   END;
  147.  
  148.   FUNCTION ALeftChop(S : String;
  149.                  len: Byte): String; Assembler;
  150.   ASM
  151.     PUSH DS
  152.     LDS SI, S
  153.     LES DI, @Result
  154.     LODSB
  155.     XOR AH, AH
  156.     XCHG AX, CX
  157.     CMP CL, Len       {if length > len,...}
  158.     JB @NoChop
  159.       ADD SI, CX      {point to end of string}
  160.       MOV CL, Len     {set length to len}
  161.       SUB SI, CX      {point to new start of string}
  162.     @NoCHop:
  163.     MOV AL, CL        {store length}
  164.     STOSB
  165.     REP MOVSB         {copy Len chars to result}
  166.     POP DS
  167.   END;
  168.  
  169.   PROCEDURE Trim(VAR S : String; C : Char);
  170.   BEGIN
  171.     WHILE S[length(S)] = C DO Dec(S[0]);
  172.   END;
  173.  
  174.   PROCEDURE TrimLead(VAR S : String; C : Char);
  175.   VAR P : Byte;
  176.   BEGIN
  177.     P := 1;
  178.     WHILE (S[P] = C) AND (P <= length(S)) DO Inc(P);
  179.     CASE P OF
  180.       0 : S[0] := #0; {string was 255 of C!}
  181.       1 : ; {not found}
  182.       ELSE
  183.         Move(S[P], S[1], succ(length(S) - P));
  184.         Dec(S[0], pred(P));
  185.     END;
  186.   END;
  187.  
  188. END.